Personal Computer World 2008 February/PCWFEB08.iso/Software/Freeware/Miro 1.0/Miro_Installer.exe/Miro_Downloader.exe/download_utils.pyc

Python Compiled Bytecode | 2007-11-12 | 5.4 KB | 213 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.5)

from os import access, F_OK
from urlparse import urlparse
import os.path as os
import re
import urllib
import filetypes
import util
from util import checkF, checkU, returnsFilename
from platformutils import unicodeToFilename, unmakeURLSafe
URIPattern = re.compile('^([^?]*/)?([^/?]*)/*(\\?(.*))?$')
MAX_FILENAME_LENGTH = 100
MAX_FILENAME_EXTENSION_LENGTH = 50

def fixFileURLS(url):
    """Fix file URLS that start with file:// instead of file:///.  Note: this
    breaks for file URLS that include a hostname, but we never use those and
    it's not so clear what that would mean anyway -- file URLs is an ad-hoc
    spec as I can tell.."""
    if url.startswith('file://'):
        if not url.startswith('file:///'):
            url = 'file:///%s' % url[len('file://'):]

        url = url.replace('\\', '/')

    return url


def defaultPort(scheme):
    if scheme == 'https':
        return 443
    elif scheme == 'http':
        return 80
    elif scheme == 'file':
        return None
    elif util.chatter:
        print 'WARNING: Assuming port 80 for scheme: %s' % scheme

    return 80


def parseURL(url):
    url = fixFileURLS(url)
    (scheme, host, path, params, query, fragment) = util.unicodify(list(urlparse(url)))
    if host.count(':') > 1:
        host = host[0:host.rfind(':')]

    if scheme == '' and util.chatter:
        print 'WARNING: %r has no scheme' % url

    if ':' in host:
        (host, port) = host.split(':')

        try:
            port = int(port)
        print 'DTV: parseURL: WARNING: invalid port for %r' % url
        port = defaultPort(scheme)

    else:
        port = defaultPort(scheme)
    host = host.lower()
    scheme = scheme.lower()
    path = path.replace('|', ':')
    if path == '' or path[0] != '/':
        path = '/' + path
    elif re.match('/[a-zA-Z]:', path):
        path = path[1:]

    fullPath = path
    if params:
        fullPath += ';%s' % params

    if query:
        fullPath += '?%s' % query

    return (scheme, host, port, fullPath)


def getFileURLPath(url):
    (scheme, host, port, path) = parseURL(url)
    if scheme != 'file':
        raise ValueError('%r is not a file URL' % url)

    return unmakeURLSafe(path)


def checkFilenameExtension(filename, httpInfo):
    checkF(filename)
    if 'content-type' in httpInfo and not filetypes.isAllowedFilename(filename):
        guessedExt = filetypes.guessExtension(httpInfo['content-type'])
        if guessedExt is not None:
            filename += guessedExt


    return filename


def nextFreeFilename(name):
    checkF(name)
    if not access(name, F_OK):
        return name

    parts = name.split('.')
    count = 1
    if len(parts) == 1:
        newname = '%s.%s' % (name, count)
        while access(newname, F_OK):
            count += 1
            newname = '%s.%s' % (name, count)
    else:
        parts[-1:-1] = [
            str(count)]
        newname = '.'.join(parts)
        while access(newname, F_OK):
            count += 1
            parts[-2] = str(count)
            newname = '.'.join(parts)
    return newname

nextFreeFilename = returnsFilename(nextFreeFilename)

def filenameFromURL(url, clean = False):
    checkU(url)

    try:
        match = URIPattern.match(url)
        if match is None:
            return unicodeToFilename(url)

        filename = match.group(2)
        query = match.group(4)
        if not filename:
            ret = query
        elif not query:
            ret = filename
        else:
            (root, ext) = os.path.splitext(filename)
            ret = u'%s-%s%s' % (root, query, ext)
        if ret is None:
            ret = u'unknown'

        if clean:
            return cleanFilename(ret)
        else:
            return unicodeToFilename(ret)
    except:
        return unicodeToFilename(u'unknown')


filenameFromURL = returnsFilename(filenameFromURL)

def cleanFilename(filename):
    for char in ':?><|*/\\"\'':
        filename = filename.replace(char, '')

    if len(filename) == 0:
        return unicodeToFilename(u'_')

    if len(filename) > MAX_FILENAME_LENGTH:
        (base, ext) = os.path.splitext(filename)
        ext = ext[:MAX_FILENAME_EXTENSION_LENGTH]
        base = base[:MAX_FILENAME_LENGTH - len(ext)]
        filename = base + ext

    if type(filename) == str:
        return unicodeToFilename(filename.decode('ascii', 'replace'))
    else:
        return unicodeToFilename(filename)

cleanFilename = returnsFilename(cleanFilename)

def saveData(target, suggested_basename, data):

    try:
        os.makedirs(target)
    except:
        pass

    filename = os.path.join(target, suggested_basename)

    try:
        tmp_filename = filename + '.part'
        tmp_filename = nextFreeFilename(tmp_filename)
        output = file(tmp_filename, 'wb')
        output.write(data)
        output.close()
    except IOError:

        try:
            os.remove(tmp_filename)
        except:
            pass

        raise

    filename = nextFreeFilename(filename)
    needsSave = True

    try:
        os.remove(filename)
    except:
        pass

    os.rename(tmp_filename, filename)
    return filename


def filterDirectoryName(name):
    return re.sub('[^a-zA-Z0-9]', '-', name)